// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE

#ifndef NIM_CPP_WRAPPER_UTIL_JSON_WRITER_H_INCLUDED
#define NIM_CPP_WRAPPER_UTIL_JSON_WRITER_H_INCLUDED

#if !defined(JSON_IS_AMALGAMATION)
#include "value.h"
#endif  // if !defined(JSON_IS_AMALGAMATION)
#include <ostream>
#include <string>
#include <vector>

// Disable warning C4251: <data member>: <type> needs to have dll-interface to
// be used by...
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) && defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif  // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)

#pragma pack(push, 8)

namespace nim_cpp_wrapper_util {
namespace Json {

class Value;

/**
 *
 * Usage:
 *  \code
 *  using namespace Json;
 *  void writeToStdout(StreamWriter::Factory const& factory, Value const& value)
 * { std::unique_ptr<StreamWriter> const writer( factory.newStreamWriter());
 *    writer->write(value, &std::cout);
 *    std::cout << std::endl;  // add lf and flush
 *  }
 *  \endcode
 */
class JSON_API StreamWriter {
protected:
    OStream* sout_;  // not owned; will not delete
public:
    StreamWriter();
    virtual ~StreamWriter();
    /** Write Value into document as configured in sub-class.
     *   Do not take ownership of sout, but maintain a reference during function.
     *   \pre sout != NULL
     *   \return zero on success (For now, we always return zero, so check the
     *   stream instead.) \throw std::exception possibly, depending on
     * configuration
     */
    virtual int write(Value const& root, OStream* sout) = 0;

    /** \brief A simple abstract factory.
     */
    class JSON_API Factory {
    public:
        virtual ~Factory();
        /** \brief Allocate a CharReader via operator new().
         * \throw std::exception if something goes wrong (e.g. invalid settings)
         */
        virtual StreamWriter* newStreamWriter() const = 0;
    };  // Factory
};      // StreamWriter

/** \brief Write into stringstream, then return string, for convenience.
 * A StreamWriter will be created from the factory, used, and then deleted.
 */
String JSON_API writeString(StreamWriter::Factory const& factory, Value const& root);

/** \brief Build a StreamWriter implementation.

* Usage:
*   \code
*   using namespace Json;
*   Value value = ...;
*   StreamWriterBuilder builder;
*   builder["commentStyle"] = "None";
*   builder["indentation"] = "   ";  // or whatever you like
*   std::unique_ptr<nim_cpp_wrapper_util::Json::StreamWriter> writer(
*      builder.newStreamWriter());
*   writer->write(value, &std::cout);
*   std::cout << std::endl;  // add lf and flush
*   \endcode
*/
class JSON_API StreamWriterBuilder : public StreamWriter::Factory {
public:
    // Note: We use a nim_cpp_wrapper_util::Json::Value so that we can add data-members to this class
    // without a major version bump.
    /** Configuration of this builder.
     *  Available settings (case-sensitive):
     *  - "commentStyle": "None" or "All"
     *  - "indentation":  "<anything>".
     *  - Setting this to an empty string also omits newline characters.
     *  - "enableYAMLCompatibility": false or true
     *  - slightly change the whitespace around colons
     *  - "dropNullPlaceholders": false or true
     *  - Drop the "null" string from the writer's output for nullValues.
     *    Strictly speaking, this is not valid JSON. But when the output is being
     *    fed to a browser's JavaScript, it makes for smaller output and the
     *    browser can handle the output just fine.
     *  - "useSpecialFloats": false or true
     *  - If true, outputs non-finite floating point values in the following way:
     *    NaN values as "NaN", positive infinity as "Infinity", and negative
     *  infinity as "-Infinity".
     *  - "precision": int
     *  - Number of precision digits for formatting of real values.
     *  - "precisionType": "significant"(default) or "decimal"
     *  - Type of precision for formatting of real values.

     *  You can examine 'settings_` yourself
     *  to see the defaults. You can also write and read them just like any
     *  JSON Value.
     *  \sa setDefaults()
     */
    nim_cpp_wrapper_util::Json::Value settings_;

    StreamWriterBuilder();
    ~StreamWriterBuilder() override;

    /**
     * \throw std::exception if something goes wrong (e.g. invalid settings)
     */
    StreamWriter* newStreamWriter() const override;

    /** \return true if 'settings' are legal and consistent;
     *   otherwise, indicate bad settings via 'invalid'.
     */
    bool validate(nim_cpp_wrapper_util::Json::Value* invalid) const;
    /** A simple way to update a specific setting.
     */
    Value& operator[](const String& key);

    /** Called by ctor, but you can use this to reset settings_.
     * \pre 'settings' != NULL (but nim_cpp_wrapper_util::Json::null is fine)
     * \remark Defaults:
     * \snippet src/lib_json/json_writer.cpp StreamWriterBuilderDefaults
     */
    static void setDefaults(nim_cpp_wrapper_util::Json::Value* settings);
};

/** \brief Abstract class for writers.
 * \deprecated Use StreamWriter. (And really, this is an implementation detail.)
 */
class JSON_API Writer {
public:
    virtual ~Writer();

    virtual String write(const Value& root) = 0;
};

/** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format
 *without formatting (not human friendly).
 *
 * The JSON document is written in a single line. It is not intended for 'human'
 *consumption,
 * but may be useful to support feature such as RPC where bandwidth is limited.
 * \sa Reader, Value
 * \deprecated Use StreamWriterBuilder.
 */
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4996)  // Deriving from deprecated class
#endif
class JSON_API FastWriter : public Writer {
public:
    FastWriter();
    ~FastWriter() override = default;

    void enableYAMLCompatibility();

    /** \brief Drop the "null" string from the writer's output for nullValues.
     * Strictly speaking, this is not valid JSON. But when the output is being
     * fed to a browser's JavaScript, it makes for smaller output and the
     * browser can handle the output just fine.
     */
    void dropNullPlaceholders();

    void omitEndingLineFeed();

public:  // overridden from Writer
    String write(const Value& root) override;

private:
    void writeValue(const Value& value);

    String document_;
    bool yamlCompatibilityEnabled_{false};
    bool dropNullPlaceholders_{false};
    bool omitEndingLineFeed_{false};
};
#if defined(_MSC_VER)
#pragma warning(pop)
#endif

/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
 *human friendly way.
 *
 * The rules for line break and indent are as follow:
 * - Object value:
 *     - if empty then print {} without indent and line break
 *     - if not empty the print '{', line break & indent, print one value per
 *line
 *       and then unindent and line break and print '}'.
 * - Array value:
 *     - if empty then print [] without indent and line break
 *     - if the array contains no object value, empty array or some other value
 *types,
 *       and all the values fit on one lines, then print the array on a single
 *line.
 *     - otherwise, it the values do not fit on one line, or the array contains
 *       object or non empty array, then print one value per line.
 *
 * If the Value have comments then they are outputed according to their
 *#CommentPlacement.
 *
 * \sa Reader, Value, Value::setComment()
 * \deprecated Use StreamWriterBuilder.
 */
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4996)  // Deriving from deprecated class
#endif
class JSON_API StyledWriter : public Writer {
public:
    StyledWriter();
    ~StyledWriter() override = default;

public:  // overridden from Writer
    /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
     * \param root Value to serialize.
     * \return String containing the JSON document that represents the root value.
     */
    String write(const Value& root) override;

private:
    void writeValue(const Value& value);
    void writeArrayValue(const Value& value);
    bool isMultilineArray(const Value& value);
    void pushValue(const String& value);
    void writeIndent();
    void writeWithIndent(const String& value);
    void indent();
    void unindent();
    void writeCommentBeforeValue(const Value& root);
    void writeCommentAfterValueOnSameLine(const Value& root);
    static bool hasCommentForValue(const Value& value);
    static String normalizeEOL(const String& text);

    using ChildValues = std::vector<String>;

    ChildValues childValues_;
    String document_;
    String indentString_;
    unsigned int rightMargin_{74};
    unsigned int indentSize_{3};
    bool addChildValues_{false};
};
#if defined(_MSC_VER)
#pragma warning(pop)
#endif

/** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
 human friendly way,
     to a stream rather than to a string.
 *
 * The rules for line break and indent are as follow:
 * - Object value:
 *     - if empty then print {} without indent and line break
 *     - if not empty the print '{', line break & indent, print one value per
 line
 *       and then unindent and line break and print '}'.
 * - Array value:
 *     - if empty then print [] without indent and line break
 *     - if the array contains no object value, empty array or some other value
 types,
 *       and all the values fit on one lines, then print the array on a single
 line.
 *     - otherwise, it the values do not fit on one line, or the array contains
 *       object or non empty array, then print one value per line.
 *
 * If the Value have comments then they are outputed according to their
 #CommentPlacement.
 *
 * \sa Reader, Value, Value::setComment()
 * \deprecated Use StreamWriterBuilder.
 */
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4996)  // Deriving from deprecated class
#endif
class JSON_API StyledStreamWriter {
public:
    /**
     * \param indentation Each level will be indented by this amount extra.
     */
    StyledStreamWriter(String indentation = "\t");
    ~StyledStreamWriter() = default;

public:
    /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
     * \param out Stream to write to. (Can be ostringstream, e.g.)
     * \param root Value to serialize.
     * \note There is no point in deriving from Writer, since write() should not
     * return a value.
     */
    void write(OStream& out, const Value& root);

private:
    void writeValue(const Value& value);
    void writeArrayValue(const Value& value);
    bool isMultilineArray(const Value& value);
    void pushValue(const String& value);
    void writeIndent();
    void writeWithIndent(const String& value);
    void indent();
    void unindent();
    void writeCommentBeforeValue(const Value& root);
    void writeCommentAfterValueOnSameLine(const Value& root);
    static bool hasCommentForValue(const Value& value);
    static String normalizeEOL(const String& text);

    using ChildValues = std::vector<String>;

    ChildValues childValues_;
    OStream* document_;
    String indentString_;
    unsigned int rightMargin_{74};
    String indentation_;
    bool addChildValues_ : 1;
    bool indented_ : 1;
};
#if defined(_MSC_VER)
#pragma warning(pop)
#endif

#if defined(JSON_HAS_INT64)
String JSON_API valueToString(Int value);
String JSON_API valueToString(UInt value);
#endif  // if defined(JSON_HAS_INT64)
String JSON_API valueToString(LargestInt value);
String JSON_API valueToString(LargestUInt value);
String JSON_API valueToString(double value,
    unsigned int precision = Value::defaultRealPrecision,
    PrecisionType precisionType = PrecisionType::significantDigits);
String JSON_API valueToString(bool value);
String JSON_API valueToQuotedString(const char* value);

/// \brief Output using the StyledStreamWriter.
/// \see nim_cpp_wrapper_util::Json::operator>>()
JSON_API OStream& operator<<(OStream&, const Value& root);

}  // namespace Json
}  // namespace nim_cpp_wrapper_util

#pragma pack(pop)

#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#pragma warning(pop)
#endif  // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)

#endif  // JSON_WRITER_H_INCLUDED
